home *** CD-ROM | disk | FTP | other *** search
/ MacHack 2001 / MacHack 2001.toast / pc / The Hacks / GrowBoxDock / Sources / PICTFile.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-01-30  |  26.6 KB  |  932 lines
  1. /*
  2.     File:        PICTFile.c
  3.  
  4.     Contains:    PICT file for simple text application
  5.  
  6.     Version:    Mac OS X
  7.  
  8.     Disclaimer:    IMPORTANT:  This Apple software is supplied to you by Apple Computer, Inc.
  9.                 ("Apple") in consideration of your agreement to the following terms, and your
  10.                 use, installation, modification or redistribution of this Apple software
  11.                 constitutes acceptance of these terms.  If you do not agree with these terms,
  12.                 please do not use, install, modify or redistribute this Apple software.
  13.  
  14.                 In consideration of your agreement to abide by the following terms, and subject
  15.                 to these terms, Apple grants you a personal, non-exclusive license, under Apple’s
  16.                 copyrights in this original Apple software (the "Apple Software"), to use,
  17.                 reproduce, modify and redistribute the Apple Software, with or without
  18.                 modifications, in source and/or binary forms; provided that if you redistribute
  19.                 the Apple Software in its entirety and without modifications, you must retain
  20.                 this notice and the following text and disclaimers in all such redistributions of
  21.                 the Apple Software.  Neither the name, trademarks, service marks or logos of
  22.                 Apple Computer, Inc. may be used to endorse or promote products derived from the
  23.                 Apple Software without specific prior written permission from Apple.  Except as
  24.                 expressly stated in this notice, no other rights or licenses, express or implied,
  25.                 are granted by Apple herein, including but not limited to any patent rights that
  26.                 may be infringed by your derivative works or by other works in which the Apple
  27.                 Software may be incorporated.
  28.  
  29.                 The Apple Software is provided by Apple on an "AS IS" basis.  APPLE MAKES NO
  30.                 WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
  31.                 WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  32.                 PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE OR IN
  33.                 COMBINATION WITH YOUR PRODUCTS.
  34.  
  35.                 IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR
  36.                 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  37.                 GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38.                 ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION
  39.                 OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, TORT
  40.                 (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN
  41.                 ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  42.  
  43.     Copyright © 1993-2001 Apple Computer, Inc., All Rights Reserved
  44. */
  45.  
  46. #include "MacIncludes.h"
  47.  
  48. #if defined(USE_UMBRELLA_HEADERS) && USE_UMBRELLA_HEADERS
  49. #include <QuickTime.h>
  50. #else
  51. #include "ImageCompression.h"
  52. // #include "GraphicsImporter.h"
  53. #endif
  54.  
  55. #include "PICTFile.h"
  56.  
  57. /* ------------------------------------------------------------------------------------    */
  58. /* GLOBALS ONLY USED BY THIS FILE */
  59. /* ------------------------------------------------------------------------------------    */
  60. #define kBufferSize    2048
  61.  
  62. static short            gPictFileRefNum;
  63. static char                gPictureBuffer[kBufferSize];
  64. static long                gAmountInBuffer;
  65. static long                gFirstCharInBuffer;
  66. //static QDProcsPtr         gSavedProcs;
  67. static QDProcs            gMyProcs;
  68. static CQDProcs           gMyColorProcs;
  69.  
  70. // --------------------------------------------------------------------------------------------------------------
  71. // INTERNAL ROUTINES
  72. // --------------------------------------------------------------------------------------------------------------
  73.  
  74. static pascal void GetPICTData(Ptr dataPtr,short byteCount)
  75. /*
  76.     replacement for the QuickDraw bottleneck routine
  77. */
  78. { 
  79.     OSStatus            err = noErr;
  80.     long            longCount;
  81.  
  82.     longCount = byteCount;
  83.     
  84.     while ( (longCount > 0) && (err == noErr) )
  85.         {
  86.         if (gAmountInBuffer == 0)
  87.             {
  88.             gAmountInBuffer = kBufferSize;
  89.             gFirstCharInBuffer = 0;
  90.             err = FSRead(gPictFileRefNum,&gAmountInBuffer,gPictureBuffer);
  91.             }
  92.  
  93.         if (gAmountInBuffer > 0)
  94.             {
  95.             long    amountToMove;
  96.             
  97.             amountToMove = gAmountInBuffer;
  98.             if (amountToMove > longCount)
  99.                 amountToMove = longCount;
  100.                 
  101.             BlockMoveData(&gPictureBuffer[gFirstCharInBuffer], dataPtr, amountToMove);
  102.             longCount -= amountToMove;
  103.             dataPtr += amountToMove;
  104.             gFirstCharInBuffer += amountToMove;
  105.             gAmountInBuffer -= amountToMove;
  106.             }
  107.             
  108.         }
  109.     
  110. } // GetPICTData
  111.  
  112.  
  113. // --------------------------------------------------------------------------------------------------------------
  114.  
  115. static OSStatus    DiskPictureDraw( WindowDataPtr pData, 
  116.     Boolean doDraw, Rect *pictureRect, Point *pOffset)
  117. {
  118.  
  119.     OSStatus        anErr;
  120.     PicHandle    picHandle;
  121.     Point        offset;
  122.     
  123.     if (pOffset)
  124.         offset = *pOffset;
  125.     else
  126.         {
  127.         offset.h = GetControlValue(pData->hScroll);
  128.         offset.v = GetControlValue(pData->vScroll);
  129.         }
  130.  
  131. #if ALLOW_QUICKTIME
  132.     if( ((PICTDataPtr)pData)->isQuickTimeImageFile )
  133.         {
  134.         GraphicsImportComponent theGraphicsImporter = 0;
  135.         
  136.         anErr = GetGraphicsImporterForFile( &pData->fileSpec, &theGraphicsImporter );
  137.         
  138.         if( noErr == anErr )
  139.             {
  140.             anErr = GraphicsImportSetQuality(
  141.                             theGraphicsImporter, 
  142.                             codecHighQuality );
  143.             }
  144.         
  145.         if( noErr == anErr )
  146.             {
  147.             Rect    destRect = ((PICTDataPtr)pData)->pictureRectangle;
  148.             
  149.             OffsetRect(&destRect, 
  150.                                 -destRect.left + 
  151.                                     pData->contentRect.left -
  152.                                     offset.h, 
  153.                                 -destRect.top + 
  154.                                     pData->contentRect.top -
  155.                                     offset.v);
  156.  
  157.             anErr = GraphicsImportSetBoundsRect( theGraphicsImporter, &destRect ); 
  158.             }
  159.         
  160.         if( noErr == anErr )
  161.             {
  162.             RgnHandle    theGripClip = NewRgn();
  163.             RectRgn( theGripClip, &pData->contentRect );
  164.             anErr = GraphicsImportSetClip( theGraphicsImporter, theGripClip );
  165.             DisposeRgn( theGripClip );
  166.             }
  167.         
  168.         if( noErr == anErr )
  169.             {
  170.             anErr = GraphicsImportDraw( theGraphicsImporter );
  171.             }
  172.         
  173.         if( 0 != theGraphicsImporter )
  174.             {
  175.             CloseComponent( theGraphicsImporter );
  176.             }
  177.         
  178.         return anErr;
  179.         }
  180. #endif
  181.  
  182.     picHandle = ((PICTDataPtr)pData)->cacheHandle;
  183.     
  184.     if (picHandle)
  185.         {
  186.  
  187.  
  188.         if (doDraw)
  189.             {
  190.             Rect    destRect;
  191.             
  192.             GetPICTRectangleAt72dpi(picHandle, &destRect);
  193.  
  194.             OffsetRect(&destRect, 
  195.                                 -destRect.left + 
  196.                                     pData->contentRect.left -
  197.                                     offset.h, 
  198.                                 -destRect.top + 
  199.                                     pData->contentRect.top -
  200.                                     offset.v);
  201.             DrawPicture(picHandle, &destRect);
  202.             }
  203.         
  204.         if (pictureRect)
  205.             {
  206.             GetPICTRectangleAt72dpi(picHandle, pictureRect);
  207.             OffsetRect(pictureRect, -pictureRect->left, -pictureRect->top);
  208.             }
  209.             
  210.         picHandle = nil;
  211.         anErr = noErr;
  212.         }
  213.     else
  214.         {
  215.         // make enough room for PICT header, including version
  216.         picHandle = (PicHandle) NewHandle(sizeof(Picture)  + sizeof(long)*8);
  217.         anErr = MemError();
  218.         nrequire(anErr, FailedNewHandle);
  219.         
  220.         gPictFileRefNum = pData->dataRefNum;
  221.         anErr = SetFPos(gPictFileRefNum, fsFromStart, 512);
  222.         nrequire(anErr, FailedSetFPos);
  223.         
  224.         gAmountInBuffer = kBufferSize;
  225.         gFirstCharInBuffer = 0;
  226.         anErr = FSRead(gPictFileRefNum, &gAmountInBuffer, gPictureBuffer);
  227.         if (anErr == eofErr)
  228.             anErr = noErr;
  229.         if (gAmountInBuffer < sizeof(Picture))
  230.             anErr = eofErr;
  231.         nrequire(anErr, FailedInitialRead);
  232.     
  233.         // copy PICT header, including version
  234.         BlockMoveData(gPictureBuffer, *picHandle, sizeof(Picture) + sizeof(long)*8);
  235.         gFirstCharInBuffer += sizeof(Picture);
  236.         gAmountInBuffer -= sizeof(Picture);
  237.         
  238.         if (doDraw)
  239.             {
  240.             Rect    destRect;
  241. #if USE_QD_GRAFPROCS
  242.             CGrafPtr thePort = GetQDGlobalsThePort();
  243. #endif
  244.             
  245.             GetPICTRectangleAt72dpi(picHandle, &destRect);
  246.             if (!gMachineInfo.haveQuickTime)
  247.                 {
  248.                 static QDGetPicUPP gGetPICTData = NULL;
  249. #if USE_QD_GRAFPROCS
  250.                 CQDProcs gprocs;
  251. #endif
  252.  
  253.                 if (!gGetPICTData) {
  254.                     gGetPICTData = NewQDGetPicUPP(GetPICTData);
  255.                 }
  256.  
  257. #if USE_QD_GRAFROCS
  258.                 if (GetPortGrafProcs(thePort, &gprocs))
  259.                     SetPortGrafProcs(thePort, &gMyColorProcs);
  260.                 else
  261.                     SetStdCProcs(&gMyColorProcs);
  262. #endif
  263.                 gMyProcs.getPicProc = gGetPICTData;
  264.                 gMyColorProcs.getPicProc = gGetPICTData;
  265.                 }
  266.                 
  267.             OffsetRect(&destRect, -destRect.left +                         pData->contentRect.left - offset.h, 
  268.                 -destRect.top + pData->contentRect.top -
  269.                 offset.v);
  270.                                                 
  271.             if (!gMachineInfo.haveQuickTime)
  272.                 {
  273.                 DrawPicture(picHandle, &destRect);
  274.                 }
  275. #if ALLOW_QUICKTIME
  276.             else
  277.                 DrawPictureFile(gPictFileRefNum, &destRect, nil);
  278. #endif
  279.             }
  280.             
  281.         if (pictureRect)
  282.             {
  283.             GetPICTRectangleAt72dpi(picHandle, pictureRect);
  284.             OffsetRect(pictureRect, -pictureRect->left, 
  285.                     -pictureRect->top);
  286.             }
  287.         }
  288.     
  289. // FALL THROUGH EXCEPTION HANDLING
  290. FailedInitialRead:
  291. FailedSetFPos:
  292.     DisposeHandle((Handle) picHandle);
  293.  
  294. FailedNewHandle:
  295.     
  296.     return(anErr);
  297.         
  298. } // DiskPictureDraw
  299.  
  300. // --------------------------------------------------------------------------------------------------------------
  301. static OSStatus GetSelectedPicture(WindowDataPtr pData, PicHandle *pResult)
  302. {
  303.     OSStatus        anErr;
  304.     PicHandle    scrapPict;
  305.     Rect        globRect;
  306.     GDHandle    theMaxDevice;
  307.     short        theDepth;
  308.     GDHandle    savedGDevice;
  309.     CGrafPtr    savedPort;
  310.     GWorldPtr    offscreenGWorld;
  311.         RgnHandle    visRgn;
  312.     Rect        bounds;
  313.         PixMapHandle    bMap;
  314.  
  315.     // save away current value for restores
  316.     GetGWorld(&savedPort, &savedGDevice);
  317.  
  318.     // determine the best way in which to allocate stuff
  319.     
  320.     SetRect(&globRect, -32760, -32760, 32760, 32760);
  321.  
  322.     theDepth = 8;
  323.     theMaxDevice = GetMaxDevice(&globRect);
  324.     if (theMaxDevice != nil)
  325.         theDepth = (**(**theMaxDevice).gdPMap).pixelSize;
  326.     
  327.     // allocate the GWorld in temp mem, or local if we run out
  328.     anErr = NewGWorld(&offscreenGWorld, theDepth, 
  329.                         &((PICTDataPtr)pData)->selectionRectangle,
  330.                         nil, nil, useTempMem);
  331.     if (anErr != noErr)
  332.         anErr = NewGWorld(&offscreenGWorld, theDepth, 
  333.                             &((PICTDataPtr)pData)->selectionRectangle,
  334.                             nil, nil, 0);
  335.     nrequire(anErr, FailedNewGWorld);
  336.  
  337.     // blow open the visRgn, and clip to the selected area
  338.     visRgn = NewRgn();
  339.     GetPortVisibleRegion(offscreenGWorld, visRgn);
  340.     RectRgn(visRgn, &globRect);
  341.     DisposeRgn(visRgn);
  342.     PortChanged(offscreenGWorld);
  343.     SetGWorld(offscreenGWorld, nil);
  344.     EraseRect(GetPortBounds(offscreenGWorld, &bounds));
  345.     ClipRect(&((PICTDataPtr)pData)->selectionRectangle);
  346.     
  347.     // Draw the picture into the offscreen
  348.     LockPixels( GetGWorldPixMap(offscreenGWorld));
  349.     {
  350.     Point    offset = {0,0};
  351.     anErr = DiskPictureDraw(pData, true, nil, &offset);
  352.     }
  353.     UnlockPixels( GetGWorldPixMap(offscreenGWorld));
  354.     nrequire(anErr, FailedDraw);
  355.  
  356.     // CopyBits in place to grab the selection
  357.     scrapPict = OpenPicture(&((PICTDataPtr)pData)->selectionRectangle);
  358.     LockPixels( GetGWorldPixMap(offscreenGWorld));
  359.         bMap = GetPortPixMap(offscreenGWorld);
  360.     CopyBits((BitMap *)*bMap, (BitMap *)*bMap, &((PICTDataPtr)pData)->selectionRectangle, &((PICTDataPtr)pData)->selectionRectangle, srcCopy, nil);
  361.     anErr = QDError();
  362.     UnlockPixels( GetGWorldPixMap(offscreenGWorld));
  363.     ClosePicture();
  364.     globRect = (**scrapPict).picFrame;
  365.     if ( (anErr == noErr) && (EmptyRect(&globRect)) )
  366.         anErr = memFullErr;
  367.         
  368.     // done with our offscreen now
  369.     SetGWorld(savedPort, savedGDevice);
  370.     DisposeGWorld(offscreenGWorld);
  371.  
  372.     if (anErr == noErr)
  373.         *pResult = scrapPict;
  374.     
  375.     return(anErr);
  376.     
  377. // EXCEPTION HANDLING
  378. FailedDraw:
  379.     DisposeGWorld(offscreenGWorld);
  380.     
  381. FailedNewGWorld:
  382.  
  383.     SetGWorld(savedPort, savedGDevice);
  384.     return(anErr);
  385.     
  386. } // GetSelectedPicture
  387.  
  388. // --------------------------------------------------------------------------------------------------------------
  389. static OSStatus CopyGWorld(WindowDataPtr pData)
  390. {
  391.     OSStatus    anErr;
  392.     PicHandle    scrapPict;
  393.     ScrapRef    scrap;
  394.  
  395.     anErr = GetSelectedPicture(pData, &scrapPict);
  396.  
  397.     if (!anErr)
  398.     {
  399.         do
  400.         {
  401.             if (anErr) break;
  402.             anErr = ClearCurrentScrap ( );
  403.             if (anErr) break;
  404.             anErr = GetCurrentScrap (&scrap);
  405.             MoveHHi ((Handle) scrapPict);
  406.             anErr = MemError ( );
  407.             if (anErr) break;
  408.             HLock ((Handle) scrapPict);
  409.             anErr = MemError ( );
  410.             if (anErr) break;
  411.             anErr = PutScrapFlavor (scrap, 'PICT', 0, GetHandleSize((Handle) scrapPict), *scrapPict);
  412.             if (anErr) break;
  413.         }
  414.         while (false);
  415.  
  416.         KillPicture(scrapPict);
  417.     }
  418.  
  419.     return anErr;
  420.     
  421. } // CopyGWorld
  422.  
  423. // --------------------------------------------------------------------------------------------------------------
  424. static pascal OSErr PICTSendDataProc(FlavorType theType, void *dragSendRefCon,
  425.                                 ItemReference theItem, DragReference theDrag)
  426. /*
  427.  *    The ItemReference is the gxShape to be sent. The dragSendRefCon is ignored.
  428. */
  429. {
  430. #pragma unused (theItem)
  431.  
  432.     OSStatus    result = noErr;
  433.  
  434.     switch (theType) 
  435.         {
  436.         case 'PICT':
  437.             {    
  438.             PicHandle     pict;
  439.             OSStatus        anErr = GetSelectedPicture((WindowDataPtr)dragSendRefCon, &pict);
  440.     
  441.             if (anErr == noErr)
  442.                 {    
  443.                 HLock((Handle)pict);
  444.                 result = SetDragItemFlavorData(theDrag, 1, 'PICT', (Ptr)*pict, GetHandleSize((Handle)pict), 0);
  445.                 KillPicture(pict);
  446.                 }
  447.             }
  448.             break;
  449.             
  450.         default:
  451.             result = badDragFlavorErr;
  452.             break;
  453.         }
  454.         
  455.     return result;
  456.     
  457. } // PICTSendDataProc
  458.  
  459.  
  460. // --------------------------------------------------------------------------------------------------------------
  461. // OOP INTERFACE ROUTINES
  462. // --------------------------------------------------------------------------------------------------------------
  463.  
  464. static OSStatus    PICTUpdateWindow(WindowPtr pWindow, WindowDataPtr pData)
  465. {
  466.     OSStatus        anErr;
  467.     RgnHandle    oldClip = NewRgn();
  468.     
  469.     EraseRect(&pData->contentRect);
  470.     
  471.     GetClip(oldClip);
  472.     ClipRect(&pData->contentRect);
  473.     anErr = DiskPictureDraw( pData, true, nil, nil);
  474.     SetClip(oldClip);
  475.     DisposeRgn(oldClip);
  476.     
  477.     DrawSelection(pData, &((PICTDataPtr)pData)->selectionRectangle, &((PICTDataPtr)pData)->patternPhase, false);
  478.     
  479.     DrawControls(pWindow);
  480.     DrawGrowIcon(pWindow);
  481.     
  482.     return(anErr);
  483.     
  484. } // PICTUpdateWindow
  485.  
  486. // --------------------------------------------------------------------------------------------------------------
  487.  
  488. static OSStatus    PICTGetDocumentRect(WindowPtr pWindow, WindowDataPtr pData, 
  489.             LongRect * documentRectangle, Boolean forGrow)
  490. {
  491. #pragma unused (pWindow, forGrow)
  492.  
  493.     RectToLongRect(&((PICTDataPtr)pData)->pictureRectangle, documentRectangle);
  494.     
  495.     return(noErr);
  496.     
  497. } // PICTGetDocumentRect
  498.  
  499. // --------------------------------------------------------------------------------------------------------------
  500.  
  501. static OSStatus    PICTCloseWindow(WindowPtr pWindow, WindowDataPtr pData)
  502. {
  503. #pragma unused (pWindow)
  504.  
  505.     DisposeHandle( (Handle) (((PICTDataPtr)pData)->cacheHandle));
  506.     
  507.     return(noErr);
  508.     
  509. } // PICTCloseWindow
  510.  
  511. // --------------------------------------------------------------------------------------------------------------
  512.  
  513. static OSStatus    PICTContentClick(WindowPtr pWindow, WindowDataPtr pData, EventRecord *pEvent)
  514. {
  515.     OSStatus            anErr = noErr;
  516.     Rect            selectionRect = ((PICTDataPtr)pData)->selectionRectangle;
  517.     Point            clickPoint = pEvent->where;
  518.     ControlHandle    theControl;
  519.     
  520.     GlobalToLocal(&clickPoint);
  521.     if (FindControl(clickPoint, pWindow, &theControl) == 0)
  522.         {
  523.         OffsetRect(&selectionRect, -GetControlValue(pData->hScroll), -GetControlValue(pData->vScroll));
  524.         if ( (gMachineInfo.haveDragMgr) && (PtInRect(clickPoint, &selectionRect)) )
  525.             {
  526.             DragAndDropArea(pWindow, pData, pEvent, 
  527.                                 &selectionRect);
  528.             }
  529.         else
  530.             {
  531.             anErr = SelectContents(pWindow, pData, pEvent, 
  532.                         &((PICTDataPtr)pData)->selectionRectangle, &((PICTDataPtr)pData)->pictureRectangle, 
  533.                         &((PICTDataPtr)pData)->patternPhase);
  534.             }
  535.         }
  536.     
  537.     return(anErr);
  538.     
  539. } // PICTContentClick
  540.  
  541. // --------------------------------------------------------------------------------------------------------------
  542.  
  543. static OSStatus    PICTAdjustCursor(WindowPtr pWindow, WindowDataPtr pData, Point * localMouse, RgnHandle globalRgn)
  544. {
  545. #pragma unused (pWindow)
  546.  
  547.     OSStatus            anErr = noErr;
  548.     CursHandle        theCross;
  549.     Rect            selectionRect = ((PICTDataPtr)pData)->selectionRectangle;
  550.     Rect            globalSelection;
  551.     
  552.     OffsetRect(&selectionRect, -GetControlValue(pData->hScroll), -GetControlValue(pData->vScroll));
  553.     
  554.     globalSelection = selectionRect;
  555.     LocalToGlobal(&TopLeft(globalSelection));
  556.     LocalToGlobal(&BotRight(globalSelection));
  557.     
  558.     if (!PtInRect(*localMouse, &selectionRect) )
  559.         {
  560.         theCross = MacGetCursor(crossCursor);
  561.         if (theCross)
  562.             {
  563.             char    oldState;
  564.             
  565.             oldState = HGetState((Handle) theCross);
  566.             HLock((Handle) theCross);
  567.             SetCursor(*theCross);
  568.             HSetState((Handle) theCross, oldState);
  569.             anErr = eActionAlreadyHandled;
  570.             }
  571.             
  572.         // make sure we get mouse-moved events if the mouse moves into the selection rect,
  573.         // so that we can change the cursor
  574.         if (!EmptyRect(&globalSelection))
  575.             {    
  576.             RgnHandle    tempRgn = NewRgn();
  577.             
  578.             RectRgn(tempRgn, &globalSelection);
  579.             DiffRgn(globalRgn, tempRgn, globalRgn);
  580.             DisposeRgn(tempRgn);
  581.             }
  582.         }
  583.     else
  584.         {
  585.         // if we're already in the selection rect, we don't need mouse-moved events as long
  586.         // as we stay there
  587.         RectRgn(globalRgn, &globalSelection);
  588.         }
  589.         
  590.     return(anErr);
  591.     
  592. } // PICTAdjustCursor
  593.  
  594. // --------------------------------------------------------------------------------------------------------------
  595.  
  596. static OSStatus    PICTDragAddFlavors(WindowPtr pWindow, WindowDataPtr pData, DragReference theDragRef)
  597. {
  598. #pragma unused (pWindow)
  599.  
  600.     static DragSendDataUPP gPICTSendDataProc = NULL;
  601.     OSStatus    anErr = noErr;
  602.     
  603.     if (!gPICTSendDataProc) {
  604.         gPICTSendDataProc = NewDragSendDataUPP(PICTSendDataProc);
  605.     }
  606.     SetDragSendProc(theDragRef, gPICTSendDataProc, pData);
  607.     AddDragItemFlavor(theDragRef, 1, 'PICT', nil, 0, 0);
  608.     
  609.     return(anErr);
  610.     
  611. } // PICTDragAddFlavors
  612.  
  613. // --------------------------------------------------------------------------------------------------------------
  614.  
  615. static OSStatus    PICTGetBalloon(WindowPtr pWindow, WindowDataPtr pData, 
  616.         Point *localMouse, short * returnedBalloonIndex, Rect *returnedRectangle)
  617. {
  618. #pragma unused (pWindow, pData)
  619.  
  620.     Rect    tempRect = ((PICTDataPtr)pData)->selectionRectangle;
  621.     
  622.     // assume generic content
  623.     *returnedBalloonIndex = iHelpPictContent;
  624.     
  625.     // see if we are within the selection
  626.     OffsetRect(&tempRect, -GetControlValue(pData->hScroll), -GetControlValue(pData->vScroll) );
  627.     SectRect(&tempRect, &pData->contentRect, &tempRect);
  628.     
  629.     if (PtInRect(*localMouse, &tempRect))
  630.         {
  631.         *returnedRectangle        = tempRect;
  632.         *returnedBalloonIndex     = iHelpPictSelection;
  633.         }
  634.         
  635.     return(noErr);
  636.     
  637. } // PICTGetBalloon
  638.  
  639. // --------------------------------------------------------------------------------------------------------------
  640.  
  641. static OSStatus    PICTPrintPage(WindowPtr pWindow, WindowDataPtr pData,
  642.                     Rect * pageRect, long *pageNum)
  643. {
  644. #pragma unused (pWindow)
  645.  
  646.     OSStatus    anErr = noErr;
  647.     short    pagesWide, pagesHigh;
  648.     Rect    pictureRect = ((PICTDataPtr)pData)->pictureRectangle;
  649.     Point    offset;
  650.     Rect    localPageRect = *pageRect;
  651.     
  652.     // calculate how many physical pages will be required to print this PICT
  653.     if (EqualRect(&pictureRect, &localPageRect))
  654.         pagesWide = pagesHigh = 1;
  655.     else
  656.         {
  657.         pagesWide = (pictureRect.right - pictureRect.left) / (localPageRect.right - localPageRect.left) + 1;
  658.         pagesHigh = (pictureRect.bottom - pictureRect.top) / (localPageRect.bottom - localPageRect.top) + 1;
  659.         }
  660.                     
  661.     // compute the offset in # of pages
  662.     offset.h = ((*pageNum - 1) % pagesWide);
  663.     offset.v = ((*pageNum - 1) / pagesWide);
  664.  
  665.     // compute the pixel offset for this page
  666.     offset.h *= localPageRect.right - localPageRect.left;
  667.     offset.v *= localPageRect.bottom - localPageRect.top;
  668.     
  669.     anErr = DiskPictureDraw( pData, true, &localPageRect, &offset);
  670.     
  671.     // tell it to stop printing when we reach the end
  672.     if (*pageNum >= (pagesWide*pagesHigh))
  673.         *pageNum = -1;
  674.     
  675.     return(anErr);
  676.     
  677. } // PICTPrintPage
  678.  
  679. // --------------------------------------------------------------------------------------------------------------
  680.  
  681. static OSStatus    PICTAdjustMenus(WindowPtr pWindow, WindowDataPtr pData)
  682. {
  683. #pragma unused (pWindow)
  684.  
  685.     OSStatus anErr = noErr;
  686.     
  687.     if (!EmptyRect(&((PICTDataPtr)pData)->selectionRectangle))
  688.         EnableCommand(cCopy);
  689.  
  690.     if     (EqualRect(&((PICTDataPtr)pData)->pictureRectangle, &((PICTDataPtr)pData)->selectionRectangle))
  691.         ChangeCommandName(cSelectAll, kMiscStrings, iSelectNoneCommand);
  692.     else
  693.         ChangeCommandName(cSelectAll, kMiscStrings, iSelectAllCommand);
  694.     EnableCommand(cSelectAll);
  695.     
  696.     return(anErr);
  697.     
  698. } // PICTAdjustMenus
  699.  
  700. // --------------------------------------------------------------------------------------------------------------
  701.  
  702. static OSStatus PICTCommand(WindowPtr pWindow, WindowDataPtr pData, short commandID, long menuResult)
  703. {
  704. #pragma unused (pWindow, menuResult)
  705.  
  706.     OSStatus anErr = noErr;
  707.     
  708.     switch (commandID)
  709.         {
  710.         case cCopy:
  711.             anErr = CopyGWorld(pData);
  712.             break;
  713.         
  714.         case cSelectAll:
  715.             // erase the old selection
  716.             DrawSelection(pData, &((PICTDataPtr)pData)->selectionRectangle, &((PICTDataPtr)pData)->patternPhase, false);
  717.             
  718.             if     (EqualRect(&((PICTDataPtr)pData)->pictureRectangle, &((PICTDataPtr)pData)->selectionRectangle))
  719.                 {
  720.                 ((PICTDataPtr)pData)->selectionRectangle.top = 0;
  721.                 ((PICTDataPtr)pData)->selectionRectangle.left = 0;
  722.                 ((PICTDataPtr)pData)->selectionRectangle.bottom = 0;
  723.                 ((PICTDataPtr)pData)->selectionRectangle.right = 0;
  724.                 }
  725.             else
  726.                 {
  727.                 ((PICTDataPtr)pData)->selectionRectangle = ((PICTDataPtr)pData)->pictureRectangle;
  728.                 }
  729.                 
  730.             // draw the new selection
  731.             DrawSelection(pData, &((PICTDataPtr)pData)->selectionRectangle, &((PICTDataPtr)pData)->patternPhase, true);
  732.             
  733.             DoAdjustCursor(pWindow, nil);
  734.             break;
  735.         }
  736.     
  737.     return(anErr);
  738.     
  739. } // PICTCommand
  740.  
  741. // --------------------------------------------------------------------------------------------------------------
  742.  
  743. static long PICTCalculateIdleTime(WindowPtr pWindow, WindowDataPtr pData)
  744. {
  745. #pragma unused (pWindow)
  746.  
  747.     if (!EmptyRect( &((PICTDataPtr)pData)->selectionRectangle))
  748.         return(0);
  749.     else
  750.         return(kMaxWaitTime);
  751.         
  752. } // PICTCalculateIdleTime
  753.  
  754. // --------------------------------------------------------------------------------------------------------------
  755.  
  756. static Boolean    PICTFilterEvent(WindowPtr pWindow, WindowDataPtr pData, EventRecord *pEvent)
  757. {
  758.     if     (
  759.         (!gMachineInfo.amInBackground) &&
  760.         (pEvent->what == nullEvent) &&
  761.         (pWindow == FrontWindow()) &&
  762.         //(EmptyRgn( ((WindowPeek)pWindow)->updateRgn)) &&
  763.         (MOVESELECTION(pEvent->when) )
  764.         )
  765.         {
  766.         // erase the old
  767.         DrawSelection(pData, &((PICTDataPtr)pData)->selectionRectangle, &((PICTDataPtr)pData)->patternPhase, false);
  768.         
  769.         // draw the new, moving onto the next pattern
  770.         DrawSelection(pData, &((PICTDataPtr)pData)->selectionRectangle, &((PICTDataPtr)pData)->patternPhase, true);
  771.         }
  772.         
  773.     return(false);
  774.     
  775. } // PICTFilterEvent
  776.  
  777. // --------------------------------------------------------------------------------------------------------------
  778.  
  779. static OSStatus    PICTMakeWindow(WindowPtr pWindow, WindowDataPtr pData)
  780. {
  781. #pragma unused (pWindow)
  782.  
  783.     Size    availableRAM;
  784.     long    amountInFile;
  785.     OSStatus    anErr = noErr;
  786.     Cursor    arrow;
  787.  
  788.     pData->pUpdateWindow         = (UpdateWindowProc)        PICTUpdateWindow;
  789.     pData->pGetDocumentRect     = (GetDocumentRectProc)        PICTGetDocumentRect;
  790.     pData->pCloseWindow         = (CloseWindowProc)            PICTCloseWindow;
  791.     pData->pContentClick         = (ContentClickProc)        PICTContentClick;
  792.     pData->pAdjustCursor         = (AdjustCursorProc)        PICTAdjustCursor;
  793.     pData->pGetBalloon             = (GetBalloonProc)            PICTGetBalloon;
  794.     pData->pAdjustMenus         = (AdjustMenusProc)            PICTAdjustMenus;
  795.     pData->pPrintPage             = (PrintPageProc)            PICTPrintPage;
  796.     pData->pCommand                 = (CommandProc)                PICTCommand;
  797.     pData->pFilterEvent             = (FilterEventProc)            PICTFilterEvent;
  798.     pData->pCalculateIdleTime    = (CalculateIdleTimeProc)    PICTCalculateIdleTime;
  799.     pData->pDragAddFlavors        = (DragAddFlavorsProc)        PICTDragAddFlavors;
  800.  
  801.     pData->hasGrow                = true;
  802.     pData->hScrollAmount        = 10;
  803.     pData->vScrollAmount        = 10;
  804.  
  805.     ((PICTDataPtr)pData)->isQuickTimeImageFile = ( pData->originalFileType != 'PICT' );
  806.  
  807. #if ALLOW_QUICKTIME
  808.  
  809.     if( ((PICTDataPtr)pData)->isQuickTimeImageFile )
  810.         {
  811.         GraphicsImportComponent theGraphicsImporter;
  812.  
  813.         if (pData->dataRefNum != -1)
  814.             {
  815.             FSClose(pData->dataRefNum);
  816.             pData->dataRefNum = -1;
  817.             }
  818.  
  819.         SetPort( GetWindowPort(pWindow) );
  820.         anErr = GetGraphicsImporterForFile( &pData->fileSpec, &theGraphicsImporter );
  821.         if( noErr == anErr )
  822.             {
  823.             anErr = GraphicsImportGetNaturalBounds( theGraphicsImporter, &((PICTDataPtr)pData)->pictureRectangle );
  824.             CloseComponent( theGraphicsImporter );
  825.             }
  826.         }
  827.     else
  828. #endif
  829.     {
  830.         // Calculate amount of available RAM for cache
  831.         {
  832.             Size grow;
  833.             availableRAM = MaxMem(&grow);
  834.         }
  835.  
  836.         // Take half of it
  837.         availableRAM >>= 1;
  838.  
  839.         // if too big, make it just big enough
  840.         GetEOF(pData->dataRefNum, &amountInFile);
  841.         amountInFile -= 512;
  842.  
  843.         SetWatchCursor();
  844.  
  845.         if (amountInFile < sizeof(Picture))
  846.         {
  847.             anErr = eErrorWhileDrawing;
  848.         }
  849.         else
  850.         {
  851.             if (availableRAM > amountInFile)
  852.             {
  853.                 Handle    theHandle = NewHandle(amountInFile);
  854.  
  855.                 if (theHandle)
  856.                 {
  857.                     SetFPos(pData->dataRefNum, fsFromStart, 512);
  858.                     FSRead(pData->dataRefNum, &amountInFile, *theHandle);
  859.  
  860.                     ((PICTDataPtr)pData)->cacheHandle = (PicHandle)theHandle;
  861.                 }
  862.             }
  863.             
  864.             // initialize the rectangle to be valid
  865.             DiskPictureDraw( pData, false, &((PICTDataPtr)pData)->pictureRectangle, nil);
  866.  
  867.         }
  868.            SetCursor(GetQDGlobalsArrow(&arrow));
  869.     }
  870.     
  871.     if (anErr == noErr)
  872.     {
  873.         Rect    pictureRect;
  874.  
  875.         pictureRect = ((PICTDataPtr)pData)->pictureRectangle;
  876.  
  877.         if ((pData->contentRect.right > pictureRect.right) && (pictureRect.right > 0))
  878.             pData->contentRect.right = pictureRect.right;
  879.         if ((pData->contentRect.bottom > pictureRect.bottom) && (pictureRect.bottom > 0))
  880.             pData->contentRect.bottom = pictureRect.bottom;
  881.  
  882.         // proportional scrolling
  883.         if( gMachineInfo.haveProxyIcons )
  884.             {
  885.             SetControlViewSize( pData->hScroll, pictureRect.right - pictureRect.left );
  886.             SetControlViewSize( pData->vScroll, pictureRect.bottom - pictureRect.top );
  887.             }
  888.         }
  889.  
  890.     return(anErr);
  891.  
  892. } // PICTMakeWindow
  893.  
  894.  
  895. // --------------------------------------------------------------------------------------------------------------
  896.  
  897. OSStatus    PICTPreflightWindow(PreflightPtr pPreflightData)
  898. {
  899.     pPreflightData->wantHScroll            = true;
  900.     pPreflightData->wantVScroll            = true;
  901.  
  902.     pPreflightData->continueWithOpen     = true;
  903.     pPreflightData->makeProcPtr         = PICTMakeWindow;
  904.  
  905.     pPreflightData->storageSize = sizeof(PICTDataRecord);
  906.  
  907.     return(noErr);
  908.  
  909. } // PICTPreflightWindow
  910.  
  911. // --------------------------------------------------------------------------------------------------------------
  912.  
  913. void PICTGetFileTypes(OSType * pFileTypes, OSType * pDocumentTypes, short * numTypes)
  914. {
  915. #if ALLOW_QUICKTIME
  916.     long version;    
  917. #endif
  918.  
  919.     pFileTypes[*numTypes]         = 'PICT';
  920.     pDocumentTypes[*numTypes]     = kPICTWindow;
  921.     (*numTypes)++;
  922.  
  923. #if ALLOW_QUICKTIME
  924.     if( (Gestalt(gestaltQuickTime, &version) == noErr) && (version >= 0x03000000) )
  925.         {
  926.         pFileTypes[*numTypes]         = 'qtif';
  927.         pDocumentTypes[*numTypes]     = kPICTWindow;
  928.         (*numTypes)++;
  929.         }
  930. #endif
  931. } // PICTGetFileTypes
  932.